﻿using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using Ausy.Silverlight.Survey.QuestionModule.Model;
using System.Collections.ObjectModel;
using Reference = Ausy.Silverlight.Survey.QuestionModule.QuestionServiceReference;
using Ausy.Silverlight.Survey.QuestionModule.Services.ServiceEventArgs;
using System.ComponentModel;

namespace Ausy.Silverlight.Survey.QuestionModule.Services
{
    /// <summary>
    /// Cette classe définit le service de gestion des questions et du questionnaire
    /// </summary>
    public class QuestionService : IQuestionService
    {
        #region Private Members

        /// <summary>
        /// Client Proxy pour gerer le questionnaire et ses questions
        /// </summary>
        private Reference.QuestionServiceClient serviceClient;

        #endregion

        #region public GetQuestionnaireByIdentifierCompleted Event

        /// <summary>
        /// Evènement lorsque le chargement est terminé
        /// </summary>
        public event EventHandler<QuestionnaireEventArgs> GetQuestionnaireByIdentifierCompleted;

        /// <summary>
        /// Evènement lorsque le chargement est terminé
        /// </summary>
        private void OnGetQuestionnaireByIdentifierCompleted(QuestionnaireEventArgs e)
        {
            EventHandler<QuestionnaireEventArgs> handler = GetQuestionnaireByIdentifierCompleted;

            if (handler != null)
            {
                handler(this, e);
            }
        }

        #endregion

        #region public CreateUserQuestionnaireCompleted Event

        /// <summary>
        /// Evènement lorsque l'enregistrement du questionnaire remplit est terminé
        /// </summary>
        public event EventHandler<EventArgs> CreateUserQuestionnaireCompleted;

        /// <summary>
        /// Evènement lorsque l'enregistrement du questionnaire remplit est terminé
        /// </summary>
        private void OnCreateUserQuestionnaireCompleted(EventArgs e)
        {
            EventHandler<EventArgs> handler = CreateUserQuestionnaireCompleted;

            if (handler != null)
            {
                handler(this, e);
            }
        }

        #endregion

        #region GetQuestionnaireByIdentifierAsync Method

        /// <summary>
        /// Cette méthode permet de récupérer un Questionnaire
        /// </summary>
        public void GetQuestionnaireByIdentifierAsync(Guid value)
        {
            this.serviceClient = new Reference.QuestionServiceClient("QuestionServiceEndPoint");
            this.serviceClient.GetQuestionnaireByIdentifierCompleted += new EventHandler<Reference.GetQuestionnaireByIdentifierCompletedEventArgs>(clientGetQuestionnaireByIdentifierCompleted);
            this.serviceClient.GetQuestionnaireByIdentifierAsync(value);
        }

        /// <summary>
        /// Cette méthode permet de traiter le retour du service pour récupére le questionnaire
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void clientGetQuestionnaireByIdentifierCompleted(object sender, Reference.GetQuestionnaireByIdentifierCompletedEventArgs e)
        {
            this.serviceClient.GetQuestionnaireByIdentifierCompleted -= this.clientGetQuestionnaireByIdentifierCompleted;
            this.serviceClient.CloseAsync();

            var questionnaireModel = new Questionnaire();
            if (e.Error == null)
            {
                Reference.Questionnaire questionnaire = e.Result;
                questionnaireModel.Identifier = questionnaire.Identifier;
                questionnaireModel.Title = questionnaire.Title;
                foreach (var question in questionnaire.QuestionCollection)
                {
                    var answerModelCollection = new Collection<Answer>();
                    foreach (var answer in question.AnswerCollection)
                    {
                        answerModelCollection.Add(new Answer() { Identifier = answer.Identifier, Text = answer.Text, IsCorrect = answer.IsCorrect });
                    }

                    var questionModel = new Question(question.Identifier, question.Text, answerModelCollection);
                    questionnaireModel.QuestionCollection.Add(questionModel);
                }
            }

            this.OnGetQuestionnaireByIdentifierCompleted(new QuestionnaireEventArgs(questionnaireModel));
        }

        #endregion

        #region CreateUserQuestionnaireAsync Method

        /// <summary>
        /// Cette méthode permet d'enregistre un Questionnaire remplit par un utilisateur
        /// </summary>
        public void CreateUserQuestionnaireAsync(UserQuestionnaire value)
        {
            this.serviceClient = new Reference.QuestionServiceClient("QuestionServiceEndPoint");
            this.serviceClient.CreateUserQuestionnaireCompleted += new EventHandler<AsyncCompletedEventArgs>(clientCreateUserQuestionnaireCompleted);

            // transformation de l'objet pour l'envoi en DataContract
            Reference.UserQuestionnaire result = new Reference.UserQuestionnaire()
            {
                Identifier = value.Identifier,
                AccountReferenceID = value.AccountReferenceID,
                QuestionnaireReferenceID = value.QuestionnaireReferenceID,
                QuestionnaireResult = value.QuestionnaireResult,
                TimeSpanComplete = value.TimeSpanComplete
            };
            result.QuestionnaireResponseCollection = new ObservableCollection<Reference.UserQuestionnaireResponse>();

            foreach (var item in value.QuestionnaireResponseCollection)
            {
                var responseResult = new Reference.UserQuestionnaireResponse()
                {
                    Identifier = item.Identifier,
                    QuestionReferenceID = item.QuestionReferenceID,
                    ResponseResult = item.ResponseResult,
                    TimeSpanComplete = item.TimeSpanComplete
                };

                responseResult.ResponseAnswerCollection = new ObservableCollection<Guid>();
                foreach (var ans in item.ResponseAnswerCollection)
                {
                    responseResult.ResponseAnswerCollection.Add(ans);
                }

                result.QuestionnaireResponseCollection.Add(responseResult);
            }

            this.serviceClient.CreateUserQuestionnaireAsync(result);
        }

        /// <summary>
        /// Cette méthode permet de traiter le retour de l'enregistre un Questionnaire remplit par un utilisateur
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void clientCreateUserQuestionnaireCompleted(object sender, AsyncCompletedEventArgs e)
        {
            this.serviceClient.CreateUserQuestionnaireCompleted -= this.clientCreateUserQuestionnaireCompleted;
            this.serviceClient.CloseAsync();

            if (e.Error == null)
            {

                this.OnCreateUserQuestionnaireCompleted(new EventArgs());
            }
        }

        #endregion
    }
}
